Filter Independent L1 Mapping Of Convolution Data Into General Purpose Register

ABSTRACT

The disclosed technology relates to graphics processing units (GPU). In one aspect, a GPU includes a general purpose register (GPR) including registers, an arithmetic logic unit (ALU) reading pixels of an image independently of a shared memory, and a level 1 (L1) cache storing pixels to implement a pixel mapping that maps the pixels read from the L1 cache into the registers of the GPR. The pixel mapping includes separating pixels of an image into three regions, with each region including a set of pixels. A first and second set of the pixels are loaded into registers corresponding to two of the three regions horizontally, and a third set of the pixels are loaded into registers corresponding to the third of the three regions vertically. Each of the registers in the first, second, and third registers are loaded as a contiguous ordered number of registers in the GPR.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of International Application No. PCT/CN2019/0118662, filed on Nov. 15, 2019, the disclosure of which is incorporated herein by reference as if reproduced in its entirety. This application also claims priority to U.S. provisional patent application Ser. No. 62/770,860, filed on Nov. 23, 2018 and entitled “Filter Independent L1 Mapping of Convolution Data Into General Purpose Register”, which is incorporated herein by reference as if reproduced in its entirety.

BACKGROUND

Graphics processors are widely used to render two-dimensional (2D) and three-dimensional (3D) images for various applications such as video games, graphics, computer-aided design (CAD), simulation and visualization tools, imaging, etc. A graphics processor may perform various graphics operations to render an image. One such graphics operation is convolution filtering, which is commonly used in image processing, 3D post processing, 2D imaging operations, etc. Convolution filtering may be used to obtain effects such as edge sharpening, blurring, noise reduction, etc. Convolution filtering may also be used for scaling, rotation, texture mapping, etc.

SUMMARY

According to one aspect of the present disclosure, there is a graphics processing unit (GPU), including a general purpose register (GPR) comprising registers; an arithmetic logic unit (ALU) configured to read pixels; and a level 1 (L1) cache, coupled to the GPR, storing the pixels read by the ALU and configured to implement a pixel mapping by: separating pixels of an image into three regions, the three regions comprising a first region having a first set of pixels, a second region having a second set of pixels and a third region having a third set of pixels, and loading the first set of pixels into one or more first registers in the first region in a horizontal manner, the second set of pixels into one or more second registers in the second region in a horizontal manner, and the third set of pixels into one or more third registers in the third region in a vertical manner, wherein each of the registers in the one or more first, second and third registers are loaded as a contiguous ordered number of registers in the GPR.

Optionally, in any of the preceding aspects, wherein the one or more third registers in the GPR are loaded as the contiguous ordered number of registers in reverse order.

Optionally, in any of the preceding aspects, wherein the one or more first registers comprise an anchor register in the first region, and the one or more third registers in the third region includes a lower ordered number of registers than the anchor register in the first region.

Optionally, in any of the preceding aspects, wherein the one or more first registers comprise an anchor register in the first region, and the one or more second registers in the second region begins at a positive offset from an anchor register in the first set of registers of the first region.

Optionally, in any of the preceding aspects, wherein the first regions has a fixed amount of pixels loaded in the one or more first registers, and the second and third regions have a variable amount of pixels respectively loaded in the one or more second and third registers based on a convolution filter size.

Optionally, in any of the preceding aspects, wherein the one or more first registers comprise an anchor register in the first region, and the L1 cache is further configured to implement the pixel mapping by loading the first set of pixels and the second set of pixels beginning with the anchor register and based on a fixed offset.

Optionally, in any of the preceding aspects, wherein the one or more first registers comprise an anchor register, and the L1 cache is further configured to implement the pixel mapping by further loading the first pixels beginning with the anchor register and based on a positive offset from the anchor register.

Optionally, in any of the preceding aspects, wherein the first region is a body, the second regions is bottom padding, and the third region is right padding.

Optionally, in any of the preceding aspects, wherein the pixels store in the GPR are convolution filter independent.

Optionally, in any of the preceding aspects, wherein a granularity of the pixels is a half warp with eight bytes per pixel mapped into the one or more first, second, and third registers of the GPR.

Optionally, in any of the preceding aspects, wherein the pixel mapping is independent of a convolution filter size and fixed relative to a location of an anchor register in the one or more first registers of the first region.

Optionally, in any of the preceding aspects, wherein the ALU is further configured to perform a convolution operation based on the pixel mapping.

Optionally, in any of the preceding aspects, wherein a convolution operation implements the convolution filter of size H×W, wherein W is a width and is a positive integer, and wherein H is a height and is a positive integer.

According to one aspect of the present disclosure, there is a computer-implemented method in a graphics processing unit (GPU) mapping pixels into registers of a general purpose register (GPR), the method including storing the pixels in a level 1 (L1) cache; reading the pixels, by an arithmetic logic unit (ALU); and mapping pixels from the L1 cache into the registers of the GPR, comprising separating pixels of an image into three regions, the three regions comprising a first region having a first set of pixels, a second region having a second set of pixels and a third region having a third set of pixels, and loading the first set of pixels into one or more first registers in the first region in a horizontal manner, the second set of pixels into one or more second registers in the second region in a horizontal manner, and the third set of pixels into one or more third registers in the third region in a vertical manner, wherein each of the one or more registers in the first, second and third registers are loaded as a contiguous ordered number of registers in the GPR.

This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter. The claimed subject matter is not limited to implementations that solve any or all disadvantages noted in the Background.

BRIEF DESCRIPTION OF THE DRAWINGS

Aspects of the present disclosure are illustrated by way of example and are not limited by the accompanying figures for which like references indicate like elements.

FIG. 1 illustrates a central processing unit in communication with a graphics processing unit of a device.

FIG. 2 is an example illustration of a processing core in a multiprocessor of FIG. 1.

FIG. 3 is an example illustration of a processing engine in a processing core of FIG. 2.

FIG. 4 shows convolution filtering of a grid within an image.

FIG. 5A is an example diagram showing pixel data corresponding to an image.

FIG. 5B is an example flow diagram demonstrating a convolution operation applied to the pixel data of FIG. 5A.

FIG. 6 illustrates a conventional method of mapping pixel data into a register.

FIG. 7A illustrates an example of mapping pixel data into a register with a half warp granularity scheme in accordance with embodiments of the disclosure.

FIG. 7B illustrates another example of mapping pixel data into a register with a half warp granularity scheme in accordance with embodiments of the disclosure.

FIGS. 8A and 8B illustrate flow diagrams of mapping pixels into registers of a general purpose register.

FIG. 9 shows a block diagram of an embodiment of a wireless device 900 in a wireless communication system.

DETAILED DESCRIPTION

The present disclosure will now be described with reference to the figures, which in general relates to graphic processing units (GPUs), and in particular, to mapping pixel data into registers of a general purpose register (GPR).

Image Signal Processors (ISPs), for example in mobile devices, are responsible for handling increasingly larger images while maintaining or even reducing the power consumption by the processing devices. One of the most common operations performed by ISPs is the convolution operation that involves applying a filter to an input image to obtain an output image of an equal or smaller size. Convolution filters may be used for many different applications, ranging from image restoration and enhancement to feature detection.

In one embodiment, pixels of the input image are mapped into a GPR separated into three regions. A first region (or padding) includes first registers, including an anchor register, in which a first set of pixels may be loaded horizontally. A second region includes second registers in which a second set of pixels may also be loaded horizontally. A third region includes third registers in which a third set of pixels is loaded vertically. The register layout in the GPR is such that loading of the pixels into the registers is in a contiguous ordered number (e.g., the registers are loaded in sequence (or sequential order) and/or loading the registers next or together in sequence).

In one embodiment, the registers in the third region have an ordered number that is less than an anchor register in the first region, and the registers in the second region begin at an offset based on the anchor register.

In another embodiment, the contiguous ordered number registers are placed in reverse order in the third region.

In still another embodiment, the mapping of pixels into the GPR is of half warp granularity pixel data with 8 bytes per pixel.

It should be understood at the outset that, although an illustrative implementation of one or more embodiments are provided below, the disclosed systems and/or methods may be implemented using any number of techniques, whether currently known or in existence. The disclosure should in no way be limited to the illustrative implementations, drawings, and techniques illustrated below, including the exemplary designs and implementations illustrated and described herein, but may be modified within the scope of the appended claims along with their full scope of equivalents.

Graphics processing typically involves coordination of two processors, a central processing unit (CPU) and a graphics processing unit (GPU). The GPU is a specialized processing unit designed to accelerate the creation of images intended for output to a display. GPUs are used in embedded systems, mobile phones, personal computers, tablet computers, portable game devices, workstations, and game consoles. A GPU is typically designed to be efficient at manipulating computer graphics. GPU's often have a highly parallel processing architecture that makes the GPU more effective than a general-purpose CPU for algorithms where processing of large blocks of data is done in parallel.

The CPU may send the GPU instructions that instruct the GPU to implement a particular graphics processing task, e.g., render a particular texture that has changed with respect to a previous frame in an image. These instructions may be coordinated by the CPU with a graphics application programming interface (API) in order to issue graphics rendering instructions that correspond to the state of the particular application's virtual environment.

In order to render textures for a particular program, a GPU may perform a series of processing tasks in a “graphics pipeline” to translate the visuals in the virtual environment into images that can be rendered onto a display. A typical graphics pipeline may include performing certain rendering or shading operations on virtual objects in the virtual space, transformation and rasterization of the virtual objects in the scene to produce pixel data suitable for output display, and additional rendering tasks on the pixels before outputting the rendered image on a display.

FIG. 1 illustrates a central processing unit in communication with a graphics processing unit of a device. A host 100 includes a central processing unit (CPU) 110 and host memory 120, in which the host 100 is communicatively coupled to a device 130, including a graphics processing unit (GPU) 140, by a bus 108 and/or bus 114. The bus may be, for example, a peripheral component interconnect express (PCI-e) bus, a motherboard-level interconnect, point-to-point serial link bus, or a shared parallel bus. In one embodiment, the bus may have a channel dedicated to a data flow for each direction. For example, a host-to-device bus transmits data from the host 100 to the device 130, and a device-to-host bus transmits data from the device 130 to the host 100.

The device 130 may be, but is not limited to, a mobile device, a desktop computer, a notebook computer, an augmented or virtual reality device, a gaming console device, or any other suitable device. In the illustrated embodiment, the device 130 may include a GPU 140. A GPU is a programmable logic chip (processor) that is specialized for graphics operations and display functions. The GPU renders images, animations and video for a “device's” display. A GPU may be located, for example, in a plug-in card (e.g. a video card), in a chipset on a motherboard (e.g., host 100), or in the same chip as a CPU (e.g., CPU 110).

The GPU 140 may comprise different types of memory for different purposes in different locations within the device 130. The different types of memory may have different access speeds, limitations, and properties. The device 130 may also include a global memory 190 that is external to the GPU 140, a texture cache 158, a constant cache 164, and a shared memory 168 within one or more multiprocessors 160 of the GPU 140. Local GPU memory may refer to any one or more of the texture cache 158, the constant cache 164, and/or the shared memory 168 within the multiprocessor 160 or accessible to a cluster of processing cores 170 and 172.

Each of the multiprocessors may include one or more processing cores (or cores) 170 and 172. In a GPU 140, the processing cores 170 and 172 may also be referred to as a stream processor (SP). Processing cores 170 and 172 can be programmed to execute processing tasks relating to a wide variety of applications, including but not limited to, linear and nonlinear data transforms, filtering of video and/or audio data, modeling operations (e.g., applying laws of physics to determine position, velocity and other attributes of objects), image rendering operations (e.g., vertex shader, geometry shader, and/or pixel shader programs), and so on.

The processing cores 170 and 172 may include registers, such as a general purpose register (GPR) 138 (or register files) that can take instructions and process data according to the instructions. In one embodiment, the processing cores 170 and 172 may be configured such that each processing core 170 and 172 processes different data according to the same instructions for the GPU 140 or multiprocessor 160. In such a case, one instruction unit 165 may be used for each multiprocessor 160.

In one embodiment, the processing cores 170 and 172 may be configured to read and write data to memory, such as shared memory 168 and global memory 190, or just read memory, such as constant cache 164 and texture cache 158. In one embodiment, the processing cores 170 and 172 may be configured to read data from local memory to the multiprocessor 160, such as a multiprocessor's shared memory 168, constant cache 164, texture cache 158, and local GPU memory, but not to another multiprocessor's shared memory 168, constant cache 164, texture cache 158, and local GPU memory.

In one other embodiment, the processing cores 170 and 172 may also be configured to read and write data to global memory 190 which is accessible to each processing core 170 and 172. Local memory may have faster access times or shorter latencies than global memory 190, but global memory 190 may have more accessibility and functionality to the processing cores 170 and 172.

FIG. 2 is an example illustration of a processing core in a multiprocessor of FIG. 1. The processing core 170 is configured to execute a large number of threads in parallel. A thread refers to an instance of a particular program executing on a particular set of input data, such as convolutional data. In one embodiment, a single-instruction, multiple-data (SIMD) instruction issue technique is used to support parallel execution of a large number of threads without providing multiple independent instruction caches 210. In other embodiments, a single-instruction multiple-thread (SIMT) techniques is used to support parallel execution of a large number of generally synchronized threads, using a common instruction cache 210 configured to issue instructions to a set of processing engines 202. Unlike an SIMD execution regime, where the processing engines 202 typically execute identical instructions, SIMT execution allows different threads to more readily follow divergent execution paths through a given thread program.

Core 170 (which can be a SIMT parallel processing core) executes instances of a single parallel program on different data across a plurality of parallel processing engines 202 included in the core 170. Thus, for example, the core 170 may be configured to execute a series of common instructions on the parallel processing engines 202 within the core 170. The series of instructions to a single parallel processing engine 202 constitutes a thread, and the collection of a certain number of concurrently executing threads among the parallel processing engines 202 within a core 170 is referred to as a “warp” or “thread group.” Additionally, a plurality of related thread groups may be active (in different phases of execution) at the same time on a core 170.

In one embodiment, each core 170 includes an array (e.g., 8, 16, etc.) of parallel processing engines 202 configured to receive SIMT instructions from a single instruction cache 210. Each processing engine 202 may also include a set of functional units (e.g., arithmetic logic units (ALUs), address generation units (AGUs), floating-point unit (FPU), load-store unit (LSU), etc.). The functional units may be pipelined, allowing new instructions to be issued before previous instructions have completed. Any combination of functional units may be provided. In one embodiment, the functional units support a variety of operations including integer and floating point arithmetic (e.g., addition and multiplication), comparison operations, Boolean operations (AND, OR, XOR), bit-shifting, and computation of various algebraic functions (e.g., planar interpolation, trigonometric, exponential, and logarithmic functions, etc.). In one other embodiment, the processing engines 202 are one of the functional units.

Each processing engine 202 stores local input data or intermediate data in a local register file 204, such as a GPR. In one embodiment, the local register file 204 is physically or logically divided into a number of P lanes, each having a number of entries (where each entry may store, for example, a 32-bit word). In one embodiment, a lane is assigned to each processing engine 202, and corresponding entries in different lanes can be populated with data for different threads executing the same program to facilitate SIMT execution. In another embodiment, each processing engine 202 accesses the local register file 204 entries in the lane assigned thereto.

Each processing engine 202 also has access to shared memory 206. In one embodiment, any one or more of the processing engines 202 can read to or write from any location in shared memory 206. In some embodiments, shared memory 206 is implemented as a shared register file. In one other embodiment, shared memory 206 can be implemented using shared cache memory.

In one embodiment, the core 170 includes parameter memory(ies) or cache(s) 208, which may be implemented, for example, as a conventional RAM or cache. Parameter memory/cache 208 can be used, for example, to hold state parameters and/or other data (e.g., various constants) that may be used by multiple threads. Processing engines 202, as discussed above, may also have access to global memory 190 (FIG. 1), which can include, for example, system memory.

In one embodiment, each processing engine 202 is multithreaded and can execute up to a number G (e.g., 24) of a group of threads concurrently, for example, by maintaining current state information associated with each thread in a different portion of its assigned lane in local register file 204. A thread (or thread of execution) indicates a specific task that may be performed with a set of one or more instructions. Threads allow a graphics application to have multiple tasks performed simultaneously by different units and further allow different graphics applications to share resources. As appreciated, the processing engines 202 are designed to switch rapidly from one thread to another so that instructions from different threads can be issued in any sequence without loss of efficiency.

Instruction cache 210 is configured such that, for any given processing cycle, the same instruction may be issued to each of the processing engines 202. Thus, at the level of a single clock cycle, core 170 implements an architecture substantially representing P number of SIMTs or SIMDs. Since each processing engine 202 is also multithreaded, supporting up to G threads concurrently, core 170 may have up to P*G threads executing concurrently. For example, if P=16 and G=24, then core 170 supports up to 384 concurrent threads.

Core 170 may process threads in “thread groups” (e.g., SIMT thread groups) since the instruction cache 210 can issue the same instruction to each of the processing engines 202 in parallel. As used herein, a “thread group” or “warp” refers to a group of up to P threads of execution of the same program on different input data, with one thread of the group being assigned to each of the processing engines 202. A warp typically has 32 threads and can perform SIMT processing simultaneously in the processing engine 202. In the case of convolution, each thread works on a pixel with multiple input channels. As a result, a warp performs 32 pixel convolutions at a time, where the data (e.g., image) typically consists of a region of 4 rows by 8 columns of pixels with N channels.

In one embodiment, a thread group may include fewer than P threads, in which case some of processing engines 202 will be idle during cycles when that thread group is being processed. In another embodiment, a thread group may include more than P threads, in which case processing will take place over consecutive clock cycles. Since each processing engine 202 can support up to G threads concurrently, it follows that up to G thread groups can be executing in core 170 at any given time.

It is appreciated that the illustrative embodiment is an example and that any number of variations and modifications may be made to the embodiment. For example, any number of processing engines may be included in each core. In some embodiments, each processing engine has its own local register file (or register), and the allocation of local register file entries per thread can be fixed or configurable as desired.

FIG. 3 is an example illustration of a processing engine in a processing core of FIG. 2. The processing engine 202 comprises an arithmetic logic unit (ALU) 310. In one embodiment, and as depicted, the ALU 310 includes a sliding window cache 310A and an accumulator 3108. In one other embodiment, the processing engine 202 is an ALU 310, as opposed to the ALU being a functional unit within the processing engine 202. The processing engine 202 may also be communicatively coupled to an instruction cache 320, a fast access uniform (FAU) memory 330, a general purpose register (GPR) (or register or register file) 340, an L1 cache 350, and a shared memory 360.

The ALU 310 is a hardware processor that is capable of performing multiply and add operations for graphics functions such as shading, convolution, pooling, and other operations by executing thread groups or warps.

In one embodiment, a sliding window function may be performed with use of the sliding window cache 310A to store calculations performed by the ALU 310. Any number of sliding window operations may be implemented including, but not limited to, Harris Corner Detector, two-dimensional (2D) correlation, 2D convolution, Gaussian Filter, Kanade-Lucas-Tomasi (KLT) feature tracker, Nagao Matsuyama filter, algorithms that require the sum of absolute differences and Sobel Filter.

As used herein, a sliding window operation may refer to performing an operation on a selection or a “window” of data elements of a data set (e.g., the data set illustrated in FIG. 5A, discussed below) and moving, shifting or sliding the window across the data elements of a data set, each time performing the operation on the selected data. The movement of the window may be virtual, or a data construct. For example, a sliding window operation may include sliding the window across an array of data elements, at a raster scan. In one embodiment, the sliding window cache 310A comprises one or more buffers such that the sliding window cache 310A may store pixels for a warp at each iteration of the ALU 310 in a first buffer and copy pixels that will be used in a subsequent iteration into a second buffer. The sliding window techniques, while employable in various embodiments, is not a focus of this disclosure.

The accumulator 310B allows for math-intensive processing, such as addition, multiplication, multiply-accumulate (MA) and shift-accumulate. The accumulator may also buffer intermediate calculations until they are no longer needed.

The instructions cache 320 stores instructions. A thread may decode instructions from the instruction cache 320 and execute the instructions in the ALU 310. The instructions cache 320 may be, for example, a ROM or another suitable form of memory.

The FAU memory 330 may also be a ROM or another suitable form of memory. The FAU memory 330 stores weights 580 (FIG. 5B) or other constants used during processing and window sliding computations in the ALU 310.

The register 340 (or GPR) is logically partitioned so that each thread has its own non-overlapped space, although multiple threads may access a space of the shared memory 360 at the same time. The ALU 310 reads from and writes to the register 340, where data for the register 340 is primarily obtained from the L1 cache 350. In the illustrated embodiment, the register 340 includes registers R₀-Rn, where n is a positive integer and may be based on a capacity of the register 340.

The L1 cache 350 is a primary, fastest cache in the core 170. The L1 cache 350 obtains data from an external memory, not shown. In one embodiment, the register 340, the L1 cache 350, and the shared memory 360 are RAMs or other suitable forms of memory.

For a convolution operation (described in more detail below with reference to FIG. 4), the ALU 310 applies a filter to an input image in order to obtain an output image. The input image comprises input pixels, and the output image comprises output pixels. Pixels represent data at coordinates (x,y) for each channel, where the channels are discrete components of the image. For example, an RGB image comprises three channels: a red channel, a green channel, and a blue channel. Typically, thread 0 of a warp performs calculations on a first group of the input pixels, thread 1 of the warp performs calculations on a second group of the input pixels, and so on. As appreciated, a thread performs calculations by the processing engine 202 (or more specifically the ALU 310) executing instructions stored in memory and performing associated calculations.

Traditionally, in order perform associated calculations, each thread uses pixels associated with other threads. Such pixels may be referred to as shared pixels. However, the register 340 cannot store shared pixels. Thus, in order to share pixels of the image, the ALU 310 may first move pixels from the register 340 to the shared memory 360 to create the shared pixels. Subsequently, the shared pixels are moved to the register 340 such that each thread in a warp has its own copy of the shared pixels. However, read and write operations involving the shared memory 360 reduce operation speed and increase power consumption.

In order to increase operation speed and decrease power consumption, embodiments of the disclosure provide processing operations (e.g., ALU-centric operations) in the GPU 140 (FIG. 1). The L1 cache 350 loads pixels into the register 340 using a pixel mapping, independently of a filter size and fixed relative to register location, described below.

Once the pixels are loaded into the register 340, the processing engine 202 (or ALU 310) may read the pixels from the register 340 and store the pixels as a sliding window in a sliding window cache 310A instead of in shared memory 360. This eliminates read and write operations associated with the shared memory 360, which in turn improves the speed of operations, reduces power consumption, and eliminates the need for the shared memory 360. By storing the pixels in the sliding window cache instead of in a shared memory, the ALU 310 stores the pixels independently of the shared memory 360.

During a sliding window operation, as described briefly above and in more detail below (with reference to FIG. 5B), the sliding window slides in a contiguous manner and in a traversing pattern. For example, the sliding window has H×W positions in a region of (4+H−1)×(8+W−1) of pixels (e.g., in a 4×8 warp pixel layout). The H×W positions may be traversed using any number of methods, such as a scan line order (i.e., traversing the first line from left to right, then to the second line, followed by left to right again, and so on) or scanning the first line from left to right, followed by the second line from right to left, the third line from left to right, and so on.

Using the sliding window operation further improves the speed of operations and reduces power consumption as data may be reused. For example, when shifting the sliding window from left to right by one column, the pixel data in the second to 8^(th) column of the sliding window cache 310A are shifted into the left neighbor (e.g., in a 4×8 warp layout). The shifted data may then be used in subsequent cycles, which eliminates the need to fetch them from registers (GPR) 340 (the 8^(th) column data are fetched from GPR for subsequent use). The accumulator 310B may then buffer intermediate calculations until the threads no longer require intermediate calculations, which also reduces hardware requirements and further reduces power consumption. That is, intermediate data is saved in the accumulator 310B and avoids outputting the data into the GPR 340 and reading them back again from the GPR 340. As appreciated, the embodiments apply to convolution, pooling, and other operations for pixels and other data.

FIG. 4 shows convolution filtering of a grid within an image. For convolution filtering, an H×W grid of picture elements (pixels) is multiplied element-by-element with an H×W grid of convolution coefficients, where H is the height and W is the width of each grid. H×W intermediate results from the element-by-element multiplies are accumulated to obtain a final result for one pixel position. The same convolution computation may be repeated for many (e.g., all) pixel positions in an image. The convolution computation for one pixel position requires H×W multiply and accumulate operations.

More specifically, image 400 may include any number of pixels in the horizontal (x) direction and any number of pixels in the vertical (y) direction. In the example shown, convolution filtering is performed on a 3×3 grid 410 of nine pixels p_(x−1,y−1) through p_(x+1,y+1) with a 3×3 kernel 420 of nine coefficients k_(0,0) through k_(2,2) to generate a new pixel at position (x,y). A convolution kernel is a set of coefficients used for convolution filtering. The coefficients may also be referred to as weights. While a 3×3 grid 410 and kernel 420 are illustrated, it is appreciated that the disclosure is not limited to such a convolution filter and that any size filter may be employed.

Convolution filtering may be classified into two types—general and separable. For general convolution filtering, the kernel coefficients are functions of both x and y, and the horizontal and vertical directions are not divisible. For separable convolution filtering, the kernel coefficients are functions of either x or y, and the horizontal and vertical directions are divisible.

General convolution filtering may be expressed as:

$p_{x,y}^{\prime} = {{S \cdot \left( {\sum\limits_{i = 0}^{W - 1}\;{\sum\limits_{j = 0}^{H - 1}\;{k_{i,j} \cdot p_{{x + i - {shiftX}},{y + j - {shiftY}}}}}} \right)} + b}$

-   -   where W is the width of the grid/kernel and H is the height of         the grid,     -   k_(i,j) is a kernel coefficient at position (i, j) in the grid,     -   S is a scaling factor and b is a bias value,     -   p_(x,y) is an original pixel at position (x, y) in the image,     -   p′_(x,y) is a filtered pixel that replaces the original pixel at         position (x, y),     -   shiftX is an offset from position (x, y) to the left of the         grid, and     -   shiftY is an offset from position (x, y) to the bottom of the         grid.     -   S may be a normalization factor of

$S = \left( {\sum\limits_{i = 0}^{W - 1}\;{\sum\limits_{i = 0}^{H - 1}\; k_{i,j}}} \right)^{- 1}$

-   -   or some other value.

Separable convolution filtering may be expressed as:

$p_{x,y}^{\prime} = {{S \cdot \left( {\sum\limits_{i = 0}^{W - 1}\;{\sum\limits_{j = 0}^{H - 1}\;{k_{i} \cdot k_{j} \cdot p_{{x + i - {shiftX}},{y + j - {shiftY}}}}}} \right)} + b}$

-   -   where k_(i) is a kernel coefficient at horizontal position i in         the grid, and     -   k_(j) is a kernel coefficient at vertical position j in the         grid.     -   The kernel coefficient at position (i, j) may be derived as:         k_(i,j)=k_(i)·k_(j).

In the example shown in FIG. 4, W=3, H=3, shiftX=0, and shiftY=0. In general, shiftX is approximately half of the width, and shiftY is approximately half of the height. ShiftX may be defined as shiftX=^(└)(W−1)/2^(┘) and ShiftY may be defined as shiftY=^(└)(H−1)/2^(┘), where ^(└)a^(┘) denotes a floor operator that gives the next lower integer value for a.

Different types of convolution filtering and different kernels may produce different effects in the filtered image. In one embodiment, a graphics application may select the type of convolution filtering to perform and the kernel to use based on image processing quality and feature requirements.

FIG. 5A is an example diagram showing pixel data corresponding to an image. Specifically, the diagram shows an example of per warp pixel data involved in a convolution with a 5×5 filter and 16 bit (B) per channel tensor format. The illustrated layout shows a memory when a level 1 (L1) cache fetches pixels of an image from an external memory into the L1 cache. As depicted, the pixel data (data elements of a data set) comprise three regions-a body 502 (e.g., top 4×8 pixels), a bottom padding 504 (e.g., bottom 4×8 pixels) and a right padding 506 (e.g., right 8×4 pixels). The number of rows in the body 502 is determined by the filter size H×W. The number of rows in the bottom padding 504 is determined by the number of rows (or height) H−1. The number of columns in the right padding 506 is also determined by the filter size H×W, where the number of columns (or width) W−1 is the number of columns.

The pixels in each region 502, 504 and 506 are denoted as pij.c0˜c3, where pij is a pixel and c0˜c3 denotes each of channels CH0, CH1, CH2 and CH3. Together, the regions form 8 rows by 12 columns, where 0≤i≤7, 0≤j≤b, a=10, and b=11. Accordingly, the pixels in the body 502 comprise pixels p00.c0˜c3 to p37.c0˜c3, the bottom padding 504 comprise pixels p40.c0˜c3 to p77.c0˜c3, and the right padding 506 comprise pixels p08.c0˜c3 to p7b.c0˜c3.

FIG. 5B is an example flow diagram demonstrating a convolution operation applied to the pixel data of FIG. 5A. In the discussion that follows, the core 170 performs a convolution operation. More specifically, in one embodiment, the ALU 310 performs the convolution operation by executing a convolution operation instruction stored in the instructions cache 320. However, it is appreciated that any other functional unit or processing unit may implement the processes described herein, and the disclosure is not limited to implementation by the core 170 and/or ALU 310.

The convolution operation instruction instructs the ALU 310 and other components of the core 170 to perform actions on a per-warp basis (i.e., if the warp comprises 32 threads, then the 32 threads simultaneously run the convolution operation instruction). Initially, the ALU 310 obtains a load instruction 520 from the instructions cache 320, and the ALU 310 sends the load instruction 530 to the L1 cache 350. The L1 cache 350 executes the load instruction 530 by retrieving the pixels P_(i,j) from an external memory (not shown), followed by loading the pixels P_(i,j) into the registers R₀-R_(n) in the register 340 using a pixel mapping. The L1 cache 320 does so on a per-warp basis, meaning each thread of the warp loads the channels CH0-CH3 of one pixel P_(i,j) at a time. In this example, since the warp comprises 32 threads, the warp loads 32 pixels P_(i,j) at a time. However, it is appreciated that the disclosure is not limited to 32 threads, and that any number of threads (e.g., 8, 16, etc.) threads may be used. Various embodiments of pixel mapping will be discussed below with reference to the various figures.

Subsequently, the ALU 310 reads the pixels P_(i,j) from registers in the body 502, stores the pixels P_(i,j) as the sliding window 595 in a first buffer (not shown) of the sliding window cache 310A, and copies into a second buffer (not shown) the pixels P_(i,j) to be used later on. The ALU 310 uses the sliding window 595 from the sliding window cache 310A and a first weight 580 from the FAU memory 330 to calculate a dot product 590 for each of the pixels P_(i,j), stores the dot products 590 in the accumulator 310B, shifts the sliding window 595 according to a traversing pattern 560, and repeats the process until the convolution operation is complete.

In one embodiment, the traversing pattern comprises sliding the window to the right by one column W−1 times until reaching a right-most position, sliding down one row and left to the farthest left column, and repeating the pattern. In this context, W is a positive integer equal to a width of the filter, as described above. In another embodiment, the sliding window 595 slides according to another traversing pattern. For instance, the traversing pattern could comprise sliding from right to left or in any other direction towards boundaries of the pixels P_(i,j).

The dot products 590 may be referred to as intermediate calculations because they occur before the convolution operation ends by adding the dot products 590.

If the sliding window 595 is 4×8 and the ALU 310 uses a filter of size H×W to perform the convolution operation, then the size of the region of the pixels P_(i,j) used is (4+H−1)×(8+W−1). In that case, the sliding window 595 slides a total of H×W times. If the image comprises 4 channels (e.g., CH0-CH3), then the ALU 310 calculates the output image 570 as follows:

output(row,column)=sum(I[row+j,column+i,k]×F[j,i,k]),

-   -   where I is an input image, F is a filter, 0≤i<S, 0≤j<R, and         0≤k≤3.         For each term, the input from I is the data for the sliding         window 595 at position (j,i), the input from F is the weight at         (j,i) stored in the FAU memory 330 and corresponding to the         sliding window 595 at position (j,i), and k is a channel. The         formula therefor defines the convolution of I and F. The ALU 310         performs S×R steps to complete an operation pipeline 310C. The         accumulator 310B adds the dot products 590 from the operation         pipeline 310C to calculate the output image 570, the accumulator         310B passes the output image 570 to the register 340, and the         register 340 stores the output image 570.

FIG. 6 illustrates a conventional method of mapping pixel data into a register. The process of mapping data into registers may be implemented by the core 170, although it is appreciated that any other functional unit or processing unit may implement the processes described herein, and the disclosure is not limited to implementation by the core 170.

After the pixel data is loaded into the L1 cache 350, the pixels P_(i,j) are mapped into registers R₀-R_(n) of the register 340. The figure shows the mapped data 600 into registers R₀-R_(n) of register 340 in the GPU 140 (FIG. 1). Similar to the example in FIG. 5A, and for purposes of discussion, the pixel data involved in the convolution uses a 5×5 filter and a 16 bits per channel tensor format, and each register R₀-R_(n) storing the data includes 32 pixels×4B. Since each channel CH0-CH3 (c0˜c3) includes 16 bits, 64 bits (16B×4 channel) is required to load the channels CH0-CH3 into the register 340.

In one example of a conventional GPU L1 mapping scheme, if each register R₀-R_(n) is 32 bits, then two registers (e.g., registers 602) are used to allocate the full 64 bits. In this case, each register R_(n) is considered a warp that includes 32 threads, where each thread is 32 bits.

The registers R₀-R_(n) may be loaded either horizontally (e.g., horizontal row 604) or vertically (e.g., vertical column 606). For example, and as illustrated, the pixels are first loaded into the body 502, then the bottom padding 504, followed by the right padding 506. In particular, pixels p00.c0c1˜p37.c0c1 are first loaded horizontally into register R12, p00.c2c3˜p37.c2c3 are next loaded horizontally into R13, P40.c0c1˜p77.c0c1 are next loaded horizontally into R14, p40.c2c3˜p77.c2c3 are next loaded horizontally into R15, p08.c0c1˜p7b.c0c1 are next loaded vertically into R16, and p08.c2c3˜p7b.c2c3 are finally loaded vertically into R17.

Registers R12 and R13 comprise the body 502, registers R14 and R15 comprise the bottom padding 504, and registers R16 and R17 comprise the right padding 506. In one embodiment, the registers R12-R17 are loaded from least significant bits to most significant bits.

While mapping the pixels P_(i,j) according to the above technique sufficiently maps all pixels P_(i,j) into the registers R₀-R_(n), all six registers R12-R17 are fully occupied in register 340. Even when using a smaller size filter, the register resources result in all of the registers R12-R17 being unavailable or occupied (albeit perhaps empty), which may form holes or gaps in the memory. For example, if the filter is a 3×3 filter instead of a 5×5 filter, half of the registers R14, R15 (gap 607) and R16, R17 (gap 608) remain empty and are not available for use. This is because when using a 3×3 filter only pixels p40.c0˜c3 to p57.c0˜c3 are mapped in the bottom padding 504, and only pixels p08.c0˜c3 to p79.c0˜c3 are mapped in the right padding 506. Registers R14, R15 and R16, R17 remain half empty and unoccupied. This results in an inefficient use of the register resources that includes a loss of processing speed and power. As register resources are critical to increasing speed and conserving power, particularly since a large number of channels are typically utilized in current applications, it is desirable to keep as many warps as possible per warp convolution pixel data in the register 340 simultaneously until all calculations along the channel dimension are completed. The more warps utilized, the faster and more power efficient applications can execute.

FIG. 7A illustrates an example of mapping pixel data into a register with a half warp granularity scheme in accordance with embodiments of the disclosure. In the mapping depicted in the figure, there is a granularity of half a warp (i.e. 16 pixels), as opposed to a full warp of 32 pixels in the above-example (FIG. 6), with 8 bytes per pixel into the general purpose register (i.e., register 340) using a 5×5 filter. The registers R₀-R_(n) of GPR 340 are loaded in a specific layout, with the registers in the right padding 506 in ordered number before the anchor register (in this example, register R12) in the body 502, and the order of the register numbers are in reverse order (e.g., lower numbered registers appear in the right padding, such as register R10).

In one embodiment, each register R_(n) is a half-warp that includes 16 threads. Using a half warp implementation and registers of 1024 bits, register R12 has 1024 bits in the GPU 140. Any thread in a warp (with 32 threads) can access a respective portion of R12 (i.e., is each thread can access 32 bits). For example, thread 0 accesses bits[31:0] of the 1024 bits, thread 1 accesses bits[63:32], and so on. Following this example,

-   -   Thread 0 loads p00.c0 into bits[15:0], p00.c1 into bits[31:16],         p00.c2 into bits[512+15:512], p00.c3 into bits[512+31:512+16],         thread 1 loads p01.c0 into bits[47:32], p01.c1 into bits[63:48],         p01.c2 into bits[512+47:512+32], p01.c3 into         bits[512+63:512+48], . . .     -   Thread 7 loads p07.c0 into bits[7×32+15:7×32], p07.c1 into         bits[7×32+31:7×32+16], p07.c2 into bits[512+7×32+15:512+7×32],         p07.c3 into bits[512+7×32+31:512+7×32+16],     -   Thread 8 loads p10.c0 into bits[8×32+15:8×32], p10.c1 into         bits[8×32+31:8×32+16], p10.c2 into bits[512+8×32+15:512+8×32],         p10.c3 into bits[512+8×32+31:512+8×32+16], . . .     -   Thread 15 loads p17.c0 into bits[15*32+15:15×32], p17.c1 into         bits[15*32+31:15×32+16], p17.c2 into bits[512+15*32+15:15×32],         p17.c3 into bits[512+15*32+31:15×32+16]. Note that the above         scheme is to load 16 pixels (i.e. p00˜p17), 64 bits per pixel,         into one register, i.e. R12.

Similarly, the next 16 pixels (i.e. p20˜p3727) may be loaded into register R13. Applying this mapping scheme, a fewer number of registers are occupied or used with smaller filters, such as a 3×3 filter. The conventional GPU L1 mapping scheme (FIG. 6) loads p00.c0 into R12 bits[15:0], p00.c1 into R12 bits[31:16], p00.c2 into R13 bits[15:0], p00.c3 into R13 bits[31:16] . . . p37.c0 into R12 bits[31×32+15:31×32], p37.c1 into R12 bits[31×32+31:31×32+16], p37.c2 into R13 bits[31×32+15:31×32], p37.c3 into R13 bits[31×32+31:31×32+16]. Thus, it is appreciated that the conventional mapping scheme “wastes” registers (leaves registers half empty) for the bottom padding 504 and the right padding 506 for smaller filters. For example, for a 3×3 filter, the bottom padding 504 are loaded into R14 and R15, but R14 and R15 are half occupied by valid data.

Additionally, in one embodiment, the bottom padding 504 begins at a register number that is the anchor register (in this example, R12)+2. For example, since the anchor register is register R12, the bottom padding 504 begins at register R14 (R12+2=R14). Moreover, the filter (in this example, a 5×5 filter) is independent of and fixed relative to register location, and results in a fewer number of registers being occupied, particularly for smaller filters. Due to the register numbering layout, the mapping 700 is formed as a contiguous ordered number of registers. Half warp granularity without this register numbering scheme would result in holes (or gaps) in the register block. For example, a half warp granularity mapping without reversing register numbering scheme, would result in registers R12, R13, R14, R15, R16 being occupied, while register R15 would be 100% empty. Thus, a hole (R15) in the register block R12-R16 would exist. An empty register within a register block is more complex, if not impossible, to utilize.

In one embodiment, loading contiguously (or loading a contiguous number) is defined as loading the registers in sequence (or sequential order) and/or loading the registers next or together in sequence. In another embodiment, loading contiguously is defined such that registers are loaded without any holes or gaps present in a block of the registers (unlike the example of FIG. 6). For example, register R10 is loaded, followed by register R11, followed by register R12, and so on. In one embodiment, the registers may be loaded in reverse and contiguous order. For example, register R11 is loaded, followed by register R10. In one embodiment, the reverse order applies to the right padding 506.

In one embodiment, having a half warp granularity, mapping the pixels P_(i,j) from the pixel data (FIG. 5A) to the registers R₀-R_(n) in the body 502 and the bottom padding 504 includes loading 16 pixels×first 4B per pixel (horizontally) into the lower 512 bits of a register (e.g. register R12), and 16 pixels×second 4B per pixel (horizontally) into the higher 512 bits of the same register (e.g. register R12). In the right padding 506, 16 pixels×first 4B per pixel (vertically) are loaded into the lower 512 bits of a register (e.g. register R11), and 16 pixels×second 4B per pixel (vertically) are loaded into the higher 512 bits of the same register (e.g. register R11). A more detailed explanation follows.

To load the registers R₀-R_(n) with the pixels P_(i,j) from the pixel data (FIG. 5A), the L1 cache 350 separates the pixels P_(i,j) into the three regions—the body 502, the bottom padding 504 and the right padding 506, described above. The number of pixels in the body 502 is equal to the number of threads in the warp. Accordingly, in the example, there are 32 pixels. The 32 pixels from the body 502 form a 4×8 rectangle (i.e., a rectangle having a width (W) of 8 pixels and a height (H) of 4 pixels). The number of pixels in the bottom padding 504 and the number of pixels in the right padding 506 are determined based on filter size H×W, described above and indicated by the load instruction 530 (FIG. 5B). In this example, with a filter size of 5×5, there are 32 pixels in the bottom padding 504 that form a 4×8 rectangle and 32 pixels in the right padding 506 that form an 8×4 rectangle.

The L1 cache 350 loads the pixels P_(i,j) into the registers R₀-Rn. In one embodiment, loading begins with an anchor register R12 indicated by the load instruction 530.

In one embodiment, the L1 cache 350 loads the pixels P_(i,j) based on offsets from the anchor register R12, such that each channel CH0-CH3 (c0˜c3) for a 64-bit pixel P_(i,j) may be loaded into a single register Rn. Specifically, the L1 cache 350 loads the respective pixels P_(i,j) into the body 502 and the pixels P_(i,j) into the bottom padding 504 based on a positive offset, and the L1 cache 350 loads the respective pixels P_(i,j) into the right padding based on a negative offset. Within the context of the disclosure, a positive offset is an offset based on the register size. For example, if each register R₀-R_(n) is 1024 bits, then the positive offset from register R12 to R13 is 1024, and the positive offset from register R12 to register R14 is 2048, and so on. In this manner, the L1 cache 350 loads the pixels P_(i,j) from body 502 into register R12 until full, followed by loading pixels P_(i,j) into register R13. Subsequently, the L1 cache 350 loads pixels P_(i,j) into the bottom padding 504 using register R14. Once register R14 is full, the pixels P_(i,j) are then loaded into register R15.

A negative offset is also an offset based on the register size, but in the opposite direction of the positive offset. For example, if each register R₀-R_(n) is 1024 bits, then the negative offset from register R14 to R13 is −1024, and the negative offset from register R13 to register R12 is −2048, and so on.

In one embodiment, the offsets are fixed offsets, where a positive number indicates a higher register number and a negative number indicates a lower register number. For instance, a fixed offset of 2 from anchor register R12 is register R14, and a fixed offset of −3 from anchor register R12 is R9.

The L1 cache 350 loads the pixels P_(i,j) into registers R12, R13 of the body 502 and into registers R14, R15 of the bottom padding 504 in a horizontal manner. For example, the L1 cache 350 loads the pixels P_(i,j) into register R12 beginning with pixel p00.c0˜c3 (FIG. 5A) and proceeding horizontally to pixel p07.c0˜c3, then moving to pixel p10.c0˜c3 and proceeding horizontally to pixel p17.c0˜c3. Subsequently, the L1 cache 350 loads the remaining pixels p20.c0˜c3 to p37.c0˜c3 from the body 502 into register R13, followed by the pixels p40.c0˜c3 to p77.c0˜c3 in the bottom padding 504 into registers R14 and R15.

The L1 cache 350 subsequently loads the pixels P_(i,j) into the registers R10, R11 of the right padding 506 in a vertical manner. For example, the L1 cache 350 begins by loading the pixels P_(i,j) of the right padding 506 into register R11 starting with pixel p08.c0˜c3 and proceeding vertically to pixel p78.c0˜c3, then moving to pixel p09.c0˜c3 and proceeding vertically to pixel p79.c0˜c3. After register R11 is filled with pixels p08.c0˜c3 to p79.c0˜c3, the L1 cache 350 loads pixels p0a.c0˜c3 to p7b.c0˜c3 into register R10 in a similar manner.

In one embodiment, per pixel data location in a register R₀-R_(n) is filter independent with respect to the anchor register (e.g. register R12). Accordingly, if a pixel is located in a particular region, then the location the pixel is mapped to in the register 340 (FIG. 3) does not depend on the filter size.

Upon completion of mapping the pixels P_(i,j) into the mapping 700, the pixel data is as follows:

-   -   P00.c0c1˜p17.c0c1 are loaded into anchor register R12's lower         512 bits, p00.c2c3˜p17.c2c3 are loaded into R12's high 512 bits.     -   P20.c0c1˜p37.c0c1 are loaded into register R13's lower 512 bits,         p20.c2c3˜p37.c2c3 are loaded into R13's high 512 bits.     -   P40.c0c1˜p57.c0c1 are loaded into register R14's lower 512 bits,         p40.c2c3˜p57.c2c3 are loaded into R14's high 512 bits.     -   P60.c0c1˜p77.c0c1 are loaded into register R15's lower 512 bits,         p60.c2c3˜p77.c2c3 are loaded into R15's high 512 bits.     -   P08.c0c1˜p79.c0c1 are loaded into R11's lower 512 bits, P08.c2c3         p79.c2c3 are loaded into R11's high 512 bits.     -   P0a.c0c1˜p7b.c0c1 are loaded into R10's lower 512 bits, P0a.c2c3         p7b.c2c3 are loaded into R10's high 512 bits.

FIG. 7B illustrates an example of mapping pixel data into a register using a 3×3 filter. Similar to FIG. 7A, in mapping 702 there is a granularity of half a warp (i.e. 16 pixels with 8 bytes per pixel into the general purpose register (i.e., register 340). The registers R₀-R_(n) are loaded in a specific layout, with the registers in the right padding 506 in ordered number before the anchor register (in this example, register R12) in the body 502, and the register numbers are used in reverse order (e.g., lower numbered registers are first placed in the right padding, such as register R11). Additionally, the bottom padding 504 begins at a register number that is the anchor register (in this example, R12)+2. For example, since the anchor register is register R12, the bottom padding 504 begins at register R14 (R12+2=R14).

Applying the process described above with reference to FIG. 7A, and using a smaller filter, a fewer number of registers are loaded with pixel data, thereby conserving register space and becoming more power efficient (as less read/write operations occur). In the depicted example, a 3×3 filter size is used in the convolution operation. As noted above, the number of rows in the body 502 and the bottom padding 504 is based on the filter size. For a 3×3 filter, the body 502 and the bottom padding 504 have 2 rows (or a height of 2), and the right padding 506 has 2 columns (or a width of 2). It is appreciated that while the discussion that follows uses a 3×3 filter size, the disclosure is not limited to a 3×3 filter, but may be any filter size that is smaller than a 5×5 filter.

The number of pixels in the body 502 is equal to the number of threads in the warp. Accordingly, in the example, there are 32 pixels. The 32 pixels from the body 502 form a 4×8 rectangle (i.e., a rectangle having a width of 8 pixels and a height of 4 pixels). The number of pixels in the bottom padding 504 and the number of pixels in the right padding 506 are based on the number of rows (2) and columns (2) as noted above. Thus, in this example having a filter size of 3×3, there are 16 pixels in the bottom padding 504 that form an 2×8 rectangle (i.e., a rectangle having a width of 8 pixels and a height of 2 pixels) and 16 pixels in the right padding 506 that form a 8×2 rectangle (i.e., a rectangle having a width of 2 pixels and a height of 8 pixels). Notably, the effective pixel height is 6 pixels (as two rows or columns of pixels are not occupied). However, when loading data from L1 cache 350 to GPR 340, the granularity is 8 pixels in height.

Since the bottom padding 504 and right padding 506 are each limited to 16 pixels, a single register R_(n) may be used to load the pixel data. For example, pixels p40.c0˜c3 to p57.c0˜c3 may be loaded into the lower and higher 512 bits of register R14 in the bottom padding 504, and pixels p08.c0˜c3 to p79.c0˜c3 may be loaded into the lower and higher 512 bits of register R11 in the right padding 506. Since 16 pixels are loaded into the bottom padding 504 and the right padding 506, no pixel data is loaded into register R15 of the bottom padding 504, resulting in an empty bottom padding 504A. Similarly, no pixel data is loaded into register R10 of the right padding 506, resulting in an empty right padding 506A. Given the layout of mapping 702, the offset of the registers and the order in which the registers are loaded, valuable register space is saved.

In other embodiments, with smaller filters, a fewer number of registers may be occupied and used in the bottom padding 504 and right padding 506.

FIGS. 8A and 8B illustrate flow diagrams of mapping pixels into registers of a general purpose register. For purposes of discussion, the processes described in the following flow diagram are implemented by core 170 of the GPU 140. However, it is appreciated that any other functional unit or processing unit may implement the processes described herein, and the disclosure is not limited to implementation by the core 170.

With reference to FIG. 8A, the core 170 stores pixels P_(i,j) of the image in order to implement a pixel mapping at step 802. In one embodiment, the pixels P_(i,j) are stored in L1 cache. At step 804, the pixels P_(i,j) are read from the L1 cache by ALU 310 independently of shared memory 360, and at step 806 the pixels P_(i,j) are mapped into registers R₀-R_(n) of the GPR 340.

Turning to FIG. 8B, the process is a detailed implementation of mapping pixels P_(i,j) into registers R₀-R_(n) of the GPR 340 (step 806). At step 808, the pixels P_(i,j) of an image are separated into three regions, as shown for example in FIG. 5A. A first region 502 includes a first set of pixels (e.g., p00.c0˜c3 to p37.c0˜c3), a second region 504 includes a second set of pixels (e.g., p40.c0˜c3 to p77.c0˜c3) and a third region 506 includes a third set of pixels (e.g., p08.c0˜c3 to p7b.c0˜c3).

At step 810, the first set of pixels (e.g., p00.c0˜c3 to p37.c0˜c3) are loaded into one or more first registers (e.g., registers R12-R13 of FIG. 7B) in the first region 502 in a horizontal manner. At step 812, the second set of pixels (e.g., p40.c0˜c3 to p77.c0˜c3) are loaded into one or more second registers (e.g. registers R14-R15) in the second region 504 in a horizontal manner, and at step 814 the third set of pixels (e.g., p08.c0˜c3 to p7b.c0˜c3) into one or more third registers in the third region 506 in a vertical manner. As shown, and depending on the size of the filter, more or less registers may be loaded into the GPR 340. For example, using a 5×5 filter, registers R10-R15 are loaded with pixel data, whereas using a 3×3 filter, registers R11-R14 are loaded with pixel data. In one embodiment, each of the registers in the first, second and third set of registers are loaded as a contiguous ordered number of registers in the GPR 340.

It is appreciated that the steps in the disclosed embodiment is not limited to the order described, but may be implemented in any order.

FIG. 9 shows a block diagram of an embodiment of a wireless device 900 in a wireless communication system. Wireless device 900 may be a cellular phone, a terminal, a handset, a personal digital assistant (PDA), or some other device. The wireless communication system may be a Code Division Multiple Access (CDMA) system, a Global System for Mobile Communications (GSM) system, or some other system.

Wireless device 900 is capable of providing bi-directional communication via a receive path and a transmit path. On the receive path, signals transmitted by base stations are received by an antenna 912 and provided to a receiver (RX) 914. Receiver 914 conditions and digitizes the received signal and provides samples to a digital section 920 for further processing. On the transmit path, a transmitter (TX) 916 receives data to be transmitted from digital section 920, processes and conditions the data, and generates a modulated signal, which is transmitted via antenna 912 to the base stations.

Digital section 920 includes various processing and interface units such as, for example, a modem processor 925, a video processor 924, an application processor 926, a display processor 928, a controller/processor 930, a graphics processor 940, cache memory system 950 and an external bus interface 960. Modem processor 925 performs processing for data transmission and reception (e.g., encoding, modulation, demodulation, and decoding). Video processor 924 performs processing on video content (e.g., still images, moving videos, and moving texts) for video applications such as camcorder, video playback, and video conferencing. Application processor 926 performs processing for various applications such as multi-way calls, web browsing, media player, and user interface. Display processor 928 performs processing to facilitate the display of videos, graphics, and texts on a display 980. Controller/processor 930 may direct the operation of various processing and interface units within digital section 920.

Graphics processor 940 performs processing for graphics applications and may be implemented as described above. For example, graphics processor 940 may include multiprocessors 160, shared memory 168, core 172, instruction unit 165, etc. (FIG. 1). Graphics processor 940 may also perform processes 802-814 in FIGS. 8A and 8B and/or other processes. Application processor 926 may execute one or more compilers that may perform processes 802-814 and/or other processes. A cache memory system 950 stores data and/or instructions for graphics processor 940. Cache memory system 950 may be implemented with configurable caches that may be assigned to different engines within graphics processor 940 and/or dedicated caches that are assigned to specific engines. External bus interface 960 facilitates transfer of data between digital section 920 (e.g., the caches) and main memory 970.

Digital section 920 may be implemented with one or more digital signal processors (DSPs), micro-processors, reduced instruction set computers (RISCs), etc. Digital section 920 may also be fabricated on one or more application specific integrated circuits (ASICs) or some other type of integrated circuits (ICs).

Certain embodiments of the present technology described herein can be implemented using hardware, software, or a combination of both hardware and software. The software used is stored on one or more of the processor readable storage devices described above to program one or more of the processors to perform the functions described herein. The processor readable storage devices can include computer readable media such as volatile and non-volatile media, removable and non-removable media. By way of example, and not limitation, computer readable media may comprise computer readable storage media and communication media. Computer readable storage media may be implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Examples of computer readable storage media include RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by a computer. A computer readable medium or media does not include propagated, modulated, or transitory signals.

Communication media typically embodies computer readable instructions, data structures, program modules or other data in a propagated, modulated or transitory data signal such as a carrier wave or other transport mechanism and includes any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as RF and other wireless media. Combinations of any of the above are also included within the scope of computer readable media.

In alternative embodiments, some or all of the software can be replaced by dedicated hardware logic components. For example, and without limitation, illustrative types of hardware logic components that can be used include Field-programmable Gate Arrays (FPGAs), Application-specific Integrated Circuits (ASICs), Application-specific Standard Products (ASSPs), System-on-a-chip systems (SOCs), Complex Programmable Logic Devices (CPLDs), special purpose computers, etc. In one embodiment, software (stored on a storage device) implementing one or more embodiments is used to program one or more processors. The one or more processors can be in communication with one or more computer readable media/storage devices, peripherals and/or communication interfaces.

It is understood that the present subject matter may be embodied in many different forms and should not be construed as being limited to the embodiments set forth herein. Rather, these embodiments are provided so that this subject matter will be thorough and complete and will fully convey the disclosure to those skilled in the art. Indeed, the subject matter is intended to cover alternatives, modifications and equivalents of these embodiments, which are included within the scope and spirit of the subject matter as defined by the appended claims. Furthermore, in the following detailed description of the present subject matter, numerous specific details are set forth in order to provide a thorough understanding of the present subject matter. However, it will be clear to those of ordinary skill in the art that the present subject matter may be practiced without such specific details.

Aspects of the present disclosure are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatuses (systems) and computer program products according to embodiments of the disclosure. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable instruction execution apparatus, create a mechanism for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.

The description of the present disclosure has been presented for purposes of illustration and description, but is not intended to be exhaustive or limited to the disclosure in the form disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the disclosure. The aspects of the disclosure herein were chosen and described in order to best explain the principles of the disclosure and the practical application, and to enable others of ordinary skill in the art to understand the disclosure with various modifications as are suited to the particular use contemplated.

The disclosure has been described in conjunction with various embodiments. However, other variations and modifications to the disclosed embodiments can be understood and effected from a study of the drawings, the disclosure, and the appended claims, and such variations and modifications are to be interpreted as being encompassed by the appended claims. In the claims, the word “comprising” does not exclude other elements or steps, and the indefinite article “a” or “an” does not exclude a plurality.

For purposes of this document, it should be noted that the dimensions of the various features depicted in the figures may not necessarily be drawn to scale.

For purposes of this document, reference in the specification to “an embodiment,” “one embodiment,” “some embodiments,” or “another embodiment” may be used to describe different embodiments or the same embodiment.

For purposes of this document, a connection may be a direct connection or an indirect connection (e.g., via one or more other parts). In some cases, when an element is referred to as being connected or coupled to another element, the element may be directly connected to the other element or indirectly connected to the other element via intervening elements. When an element is referred to as being directly connected to another element, then there are no intervening elements between the element and the other element. Two devices are “in communication” if they are directly or indirectly connected so that they can communicate electronic signals between them.

For purposes of this document, the term “based on” may be read as “based at least in part on.”

For purposes of this document, without additional context, use of numerical terms such as a “first” object, a “second” object, and a “third” object may not imply an ordering of objects, but may instead be used for identification purposes to identify different objects.

The foregoing detailed description has been presented for purposes of illustration and description. It is not intended to be exhaustive or to limit the subject matter claimed herein to the precise form(s) disclosed. Many modifications and variations are possible in light of the above teachings. The described embodiments were chosen in order to best explain the principles of the disclosed technology and its practical application to thereby enable others skilled in the art to best utilize the technology in various embodiments and with various modifications as are suited to the particular use contemplated. It is intended that the scope be defined by the claims appended hereto.

Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims. 

1. A graphics processing unit (GPU), comprising: a general purpose register (GPR) comprising registers; an arithmetic logic unit (ALU) comprising a cache and configured to read pixels of an image from a level 1 (L1) cache, wherein the L1 cache is different from a shared memory; and the L1 cache coupled to the GPR and configured to store the pixels read by the ALU and implement a pixel mapping that maps the pixels read from the L1 cache into the registers of the GPR, wherein implementing the pixel mapping comprises: allocating the pixels into three regions of the GPR; and loading a first set of pixels into one or more first registers corresponding to the first region in a horizontal manner, a second set of pixels into one or more second registers corresponding to the second region in a horizontal manner, and a third set of pixels into one or more third registers corresponding to the third region in a vertical manner, wherein: each of the registers in the one or more first, second, and third registers are loaded with the respective first, second, and third set of pixels in a contiguous manner.
 2. The GPU of claim 1, wherein the one or more third registers in the GPR are loaded with the third set of pixels in a reverse contiguous order.
 3. The GPU of claim 1, wherein: the one or more first registers comprise an anchor register in the one or more first registers corresponding to the first region, and the one or more third registers corresponding to the third region includes a lower ordered number of registers than the anchor register.
 4. The GPU of claim 1, wherein: the one or more first registers comprise an anchor register in the one or more first registers corresponding to the first region, and the one or more second registers corresponding to the second region begins at a positive offset from the anchor register.
 5. The GPU of claim 1, wherein: the first region has a fixed amount of pixels loaded in the one or more first registers, the second region has a variable amount of pixels loaded in the one or more second register based on a convolution filter size, and the third region has a variable amount of pixels loaded in the one or more third registers based on a convolution filter size.
 6. The GPU of claim 1, wherein: the one or more first registers comprise an anchor register, and the L1 cache is further configured to implement the pixel mapping by loading the first set of pixels and the second set of pixels beginning with the anchor register and based on a fixed offset.
 7. The GPU of claim 1, wherein the one or more first registers comprise an anchor register, and the L1 cache is further configured to implement the pixel mapping by further loading the first set of pixels beginning with the anchor register and based on a positive offset from the anchor register.
 8. The GPU of claim 1, wherein the first region is a body, the second regions is a bottom padding, and the third region is a right padding.
 9. The GPU of claim 1, wherein the pixels stored in the GPR are convolution filter independent.
 10. The GPU of claim 1, wherein a granularity of the pixels is a half warp with eight bytes per pixel mapped into the one or more first, second, and third registers of the GPR.
 11. The GPU of claim 1, wherein the pixel mapping is independent of a convolution filter size and fixed relative to a location of an anchor register in the one or more first registers of the first region.
 12. The GPU of claim 1, wherein the ALU is further configured to perform a convolution operation based on the pixel mapping.
 13. The GPU of claim 12, wherein the convolution operation implements a convolution filter of size H×W, wherein W is a width and is a positive integer, and wherein H is a height and is a positive integer.
 14. A computer-implemented method in a graphics processing unit (GPU) mapping pixels of an image into registers of a general purpose register (GPR), the method comprising: storing the pixels in a level 1 (L1) cache; reading the pixels, by an arithmetic logic unit (ALU) and from a cache included in the ALU, wherein the cache included in the ALU is different from a shared memory; and mapping the pixels read from the L1 cache into the registers of the GPR, comprising: allocating the pixels into three regions of the GPR; and loading a first set of pixels into one or more first registers corresponding to the first region in a horizontal manner, a second set of pixels into one or more second registers corresponding to the second region in a horizontal manner, and a third set of pixels into one or more third registers corresponding to the third region in a vertical manner, wherein: each of the registers in the one or more first, second, and third registers are loaded with the respective first, second, and third set of pixels in as an order.
 15. The computer-implemented method of claim 14, further comprising loading the one or more third registers in the GPR with the third set of pixels in a reverse contiguous manner.
 16. The computer-implemented method of claim 14, wherein: the one or more first registers comprise an anchor register, and at least one of: the one or more third registers corresponding to the third region includes a lower ordered number of registers than the anchor register, or the one or more second registers corresponding to the second region begins at a positive offset from the anchor register.
 17. The computer-implemented method of claim 14, wherein: the first region has a fixed amount of pixels loaded in the one or more first registers, the second region has a variable amount of pixels loaded in the one or more second registers based on a convolution filter size, and the third region has a variable amount of pixels loaded in the one or more third registers based on a convolution filter size, wherein: the first region is a body, the second regions is bottom padding and the third region is right padding.
 18. The computer-implemented method of claim 14, wherein: the one or more first registers comprise an anchor register in the first region, and the L1 cache is further configured to implement the pixel mapping by either: loading the first set of pixels and the second set of pixels beginning with the anchor register and based on a fixed offset, or loading the first pixels beginning with the anchor register and based on a positive offset from the anchor register.
 19. The computer-implemented method of claim 14, wherein the pixels stored in the GPR are convolution filter independent and wherein a granularity of the pixels is a half warp with eight bytes per pixel mapped into the one or more first, second, and third registers of the GPR.
 20. The computer-implemented method of claim 14, wherein: the pixel mapping is independent of a convolution filter size and fixed relative to a location of an anchor register in the one or more first registers of the first region, the ALU is configured to perform a convolution operation based on the pixel mapping, wherein the convolution operation implements a convolution filter of size H×W, where W is a width and is a positive integer, and where H is a height and is a positive integer. 